home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Sample Code / Movie Data Exchange / ImportExportMovie / ImportExportMovie.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-28  |  10.5 KB  |  435 lines  |  [TEXT/KAHL]
  1. /*
  2.     File:        ImportExportMovie.c
  3.  
  4.     Written by:    Peter Hoddie
  5.  
  6.     Copyright:    © 1992 by Apple Computer, Inc., all rights reserved.
  7.  
  8. */
  9.  
  10. #include <SysEqu.h>
  11.  
  12. #include <Memory.h>
  13. #include <Resources.h>
  14. #include <QuickDraw.h>
  15. #include <Fonts.h>
  16. #include <StandardFile.h>
  17. #include <ToolUtils.h>
  18. #include <Desk.h>
  19. #include <GestaltEqu.h>
  20.  
  21. #include <Movies.h>
  22. #include <QuickTimeComponents.h>
  23.  
  24. #define kExportMenu 155
  25. #define kMyCustomSaveDialog 128
  26. #define kMyMBar 128
  27. #define kAboutBox 129
  28.  
  29. enum {
  30.     menuApple = 128,
  31.     menuFile
  32. };
  33. enum {
  34.     fileImport = 1,
  35.     fileExport,
  36.     fileUnused1,
  37.     fileQuit
  38. };
  39.  
  40. pascal Boolean myImportFileFilter(ParmBlkPtr PB);
  41. void importMovie(void);
  42.  
  43. pascal Boolean myExportFileFilter(ParmBlkPtr PB);
  44. pascal short myDlgHook(short item, DialogPtr theDialog, short *whichConverter);
  45. void exportMovie(void);
  46.  
  47. Boolean doMenuItem(long menuChoice);
  48.  
  49. //
  50. // IMPORT MOVIE
  51. //
  52.  
  53. /*
  54.     The import file filter checks the given file to see if there is a
  55.         Movie Import Component available which could translate it into a
  56.         movie. If one is available, the file is allowed to be shown.
  57. */
  58. pascal Boolean myImportFileFilter(ParmBlkPtr PB)
  59. {
  60.     ComponentDescription cd;
  61.     Boolean result = true;            // true means we don't want it
  62.  
  63.     cd.componentType = MovieImportType;
  64.     cd.componentSubType = PB->fileParam.ioFlFndrInfo.fdType;
  65.     cd.componentManufacturer = 0;
  66.     cd.componentFlags = canMovieImportFiles;
  67.     cd.componentFlagsMask = canMovieImportFiles;
  68.  
  69.     if (FindNextComponent(0, &cd))    // search for component to do the work
  70.         result = false;
  71.  
  72.     return result;
  73. }
  74.  
  75. void importMovie(void)
  76. {
  77.     OSErr err;
  78.     StandardFileReply reply;
  79.     SFReply putFile;
  80.     FSSpec newFile;
  81.     Str255 newName;
  82.     Point where = {100,100};
  83.     Component c;
  84.     ComponentDescription cd;
  85.  
  86.     StandardGetFilePreview(myImportFileFilter, 0, nil, &reply);
  87.     if (!reply.sfGood) return;
  88.  
  89.     BlockMove(reply.sfFile.name, newName, sizeof(reply.sfFile.name));
  90.     newName[++newName[0]] = '!';
  91.     SFPutFile(where, "\pName imported movie:", newName, nil, &putFile);
  92.     if (!putFile.good) return;
  93.  
  94.     FSMakeFSSpec(putFile.vRefNum, 0, putFile.fName, &newFile);
  95.  
  96.     cd.componentType = MovieImportType;
  97.     cd.componentSubType = reply.sfType;
  98.     cd.componentManufacturer = 0;
  99.     cd.componentFlags = canMovieImportFiles;
  100.     cd.componentFlagsMask = canMovieImportFiles;
  101.     c = FindNextComponent(nil, &cd);
  102.     if (!c) return;                        // too weird. no import component exists
  103.     GetComponentInfo(c, &cd, nil, nil, nil);
  104.     if (cd.componentFlags & hasMovieImportUserInterface) {
  105.         MovieImportComponent importer;
  106.         Boolean canceled = false;
  107.  
  108.         importer = OpenComponent(c);
  109.         err = MovieImportDoUserDialog(importer, &reply.sfFile, nil, &canceled);
  110.         if (err || canceled) {
  111.             CloseComponent(importer);
  112.             return;
  113.         }
  114.         err = ConvertFileToMovieFile(&reply.sfFile, &newFile, 'TVOD', reply.sfScript, nil,
  115.             createMovieFileDeleteCurFile, importer, (MovieProgressProcPtr)-1, 0);
  116.         CloseComponent(importer);
  117.     }
  118.     else {
  119.         // no import user interface option, so let the toolbox open the component
  120.         err = ConvertFileToMovieFile(&reply.sfFile, &newFile, 'TVOD', reply.sfScript, nil,
  121.             createMovieFileDeleteCurFile, nil, (MovieProgressProcPtr)-1, 0);
  122.     }
  123.     if (err) {
  124.         SysBeep(1);
  125.         DeleteMovieFile(&newFile);
  126.     }
  127. }
  128.  
  129. //
  130. // EXPORT MOVIE
  131. //
  132.  
  133. /*
  134.     This file filter is particularly slimey. Standard File Preview automatically tries
  135.         to show all non-movie files that it could convert to movies. In a dialog to select
  136.         a movie to export, we only want to see movies. So what we do here is refetch the
  137.         file type for the selected file via the File System to see if Standard File
  138.         Preview is lying to us about the file type. If the file is indeed a movie, we
  139.         let it be shown. 
  140. */
  141. pascal Boolean myExportFileFilter(ParmBlkPtr PB)
  142. {
  143.     FSSpec fss;
  144.     FInfo info;
  145.  
  146.     FSMakeFSSpec(-*(short *)SFSaveDisk, *(long *)CurDirStore, PB->fileParam.ioNamePtr, &fss);
  147.     FSpGetFInfo(&fss, &info);
  148.     if (info.fdType == MovieFileType)
  149.         return false;
  150.     else
  151.         return true;
  152. }
  153.  
  154. /*
  155.     This skanky hook just constantly (and stupidly) watches the value of the export
  156.         types menu and jams it back into our local variable below.
  157. */
  158. pascal short myDlgHook(short item, DialogPtr theDialog, short *whichConverter)
  159. {
  160.     short kind;
  161.     Handle h;
  162.     Rect r;
  163.  
  164.     if (GetWRefCon(theDialog) != sfMainDialogRefCon)
  165.         return item;
  166.  
  167.     GetDItem(theDialog, sfItemNewFolderUser+1, &kind, &h, &r); // first custom item
  168.     *whichConverter = GetCtlValue((ControlHandle)h);
  169.  
  170.     return item;
  171. }
  172.  
  173. void exportMovie(void)
  174. {
  175.     OSErr err;
  176.     StandardFileReply reply, putFile;
  177.     OSType movieType = MovieFileType;
  178.     MenuHandle mh = GetMenu(kExportMenu);
  179.     ComponentDescription cd;
  180.     Component c = 0;
  181.     Point where = {0,0};
  182.     Str255 newName;
  183.     short convertItem = 1;
  184.     Component **exportComponents;
  185.     Movie theMovie = nil;
  186.     short resRef;
  187.     OSType creator;
  188.  
  189.     StandardGetFilePreview(myExportFileFilter, 1, &movieType, &reply);
  190.     if (!reply.sfGood) return;
  191.  
  192.     // get the movie.
  193.     OpenMovieFile(&reply.sfFile, &resRef, fsRdPerm);
  194.         NewMovieFromFile(&theMovie, resRef, nil, nil,
  195.                  0, nil);
  196.     CloseMovieFile(resRef);
  197.     if (!theMovie) return;
  198.     SetMovieProgressProc(theMovie, (MovieProgressProcPtr)-1, 0);
  199.  
  200.     // build a list of all export components which are applicable to this movie
  201.     exportComponents = (Component **)NewHandle(0);
  202.  
  203.     cd.componentType = MovieExportType;
  204.     cd.componentSubType = 0;
  205.     cd.componentManufacturer = 0;
  206.     cd.componentFlags = canMovieExportFiles;
  207.     cd.componentFlagsMask = canMovieExportFiles;
  208.     while (c = FindNextComponent(c, &cd)) {
  209.         Handle h = NewHandle(4);
  210.         ComponentDescription exportCD;
  211.  
  212.         if (GetComponentInfo(c, &exportCD, h, nil, nil) == noErr) {
  213.             Str255 s;
  214.             Handle h2 = NewHandle(4);
  215.             ComponentDescription mhcd;
  216.             Component mediaHandler;
  217.  
  218.             mhcd.componentType = MediaHandlerType;
  219.             mhcd.componentSubType = exportCD.componentManufacturer;
  220.             mhcd.componentManufacturer = 0;
  221.             mhcd.componentFlags = 0;
  222.             mhcd.componentFlagsMask = 0;
  223.             if (mediaHandler = FindNextComponent(0, &mhcd)) {
  224.                 long trackCount = GetMovieTrackCount(theMovie);
  225.                 long i;
  226.                 Boolean foundMedia = true;
  227.  
  228.                 // make sure the media type the component can export is in the movie
  229.                 if (exportCD.componentManufacturer) {
  230.                     foundMedia = false;
  231.                     for (i=1; i<=trackCount; i++) {
  232.                         Track t = GetMovieIndTrack(theMovie, i);
  233.                         OSType mediaType;
  234.     
  235.                         GetMediaHandlerDescription(GetTrackMedia(t), &mediaType, nil, nil);
  236.                         foundMedia = (mediaType == exportCD.componentManufacturer);
  237.                         if (foundMedia) break;
  238.                     }
  239.                 }
  240.  
  241.                 if (foundMedia && (GetComponentInfo(mediaHandler, nil, h2, nil, nil) == noErr)) {
  242.                     Str255 s;
  243.  
  244.                     // build menu name in un-international friendly way
  245.                     if (exportCD.componentManufacturer) {
  246.                         BlockMove(*h2, s, sizeof(s));
  247.                         s[++s[0]] = ' ';
  248.                         s[++s[0]] = 't';
  249.                         s[++s[0]] = 'o';
  250.                         s[++s[0]] = ' ';
  251.                     }
  252.                     else
  253.                         s[0] = 0;
  254.                     BlockMove(*h + 1, &s[s[0] + 1], **h);
  255.                     s[0] += **h;
  256.  
  257.                     AppendMenu(mh, s);
  258.                     PtrAndHand((Ptr)&c, (Handle)exportComponents, sizeof(c));
  259.                     DisposHandle(h);
  260.                 }
  261.             }
  262.         }
  263.  
  264.         DisposHandle(h);
  265.     }
  266.     InsertMenu(mh, -1);
  267.  
  268.     if (GetHandleSize((Handle)exportComponents) == 0) {
  269.         // no export components for this movie are available
  270.         SysBeep(1);
  271.         goto bail;
  272.     }
  273.  
  274.     BlockMove(reply.sfFile.name, newName, 255);
  275.     newName[++newName[0]] = '!';
  276.     CustomPutFile("\pExport a file", newName, &putFile,
  277.                     kMyCustomSaveDialog, where, (DlgHookYDProcPtr)myDlgHook, 
  278.                     nil, nil, nil, (void *)&convertItem);
  279.     if (!putFile.sfGood) goto bail;
  280.  
  281.     GetComponentInfo((*exportComponents)[convertItem - 1], &cd, nil, nil, nil);
  282.  
  283.     // cheap map in the application to allow us to chose the file creator
  284.     {
  285.     Handle h = GetResource('fMap', 128);
  286.     short count = GetHandleSize(h) / (sizeof(OSType) * 2);
  287.     OSType *creators = *(OSType **)h;
  288.  
  289.     creator = '????';
  290.     while (count-- > 0) {
  291.         if (*creators++ == cd.componentSubType) {
  292.             creator = *creators;
  293.             break;
  294.         }
  295.         creators++;
  296.     }
  297.     }
  298.  
  299.     if (cd.componentFlags & hasMovieExportUserInterface) {
  300.         MovieExportComponent exporter;
  301.         Boolean canceled = false;
  302.  
  303.         exporter = OpenComponent((*exportComponents)[convertItem - 1]);
  304.         err = MovieExportDoUserDialog(exporter, &reply.sfFile, nil, &canceled);
  305.         if (err || canceled) {
  306.             CloseComponent(exporter);
  307.             return;
  308.         }
  309.         err = ConvertMovieToFile(theMovie, nil, &putFile.sfFile,
  310.             cd.componentSubType, creator, putFile.sfScript, nil, createMovieFileDeleteCurFile,
  311.             exporter);
  312.         CloseComponent(exporter);
  313.     }
  314.     else {
  315.         // no user interface available. let the movie toolbox do the hard part
  316.         err = ConvertMovieToFile(theMovie, nil, &putFile.sfFile,
  317.             cd.componentSubType, creator, putFile.sfScript, nil, createMovieFileDeleteCurFile,
  318.             (ComponentInstance)(*exportComponents)[convertItem - 1]);
  319.     }
  320.  
  321.     if (err)
  322.         SysBeep(1);
  323.  
  324. bail:
  325.     DeleteMenu(kExportMenu);
  326.     DisposeMenu(mh);
  327.     DisposeMovie(theMovie);
  328.     DisposHandle((Handle)exportComponents);
  329. }
  330.  
  331. Boolean doMenuItem(long menuChoice)
  332. {
  333.     Boolean done = false;
  334.     short whichMenu = HiWord(menuChoice);
  335.     short whichItem = LoWord(menuChoice);
  336.  
  337.     switch (whichMenu) {
  338.         case menuApple:    
  339.                     if (whichItem > 2) {
  340.                         Str255 daName;
  341.                         
  342.                         GetItem(GetMHandle(menuApple), whichItem, daName);
  343.                         OpenDeskAcc(daName);
  344.                     }
  345.                     else
  346.                         Alert(kAboutBox, nil);
  347.                     break;
  348.  
  349.         case menuFile:    
  350.                     switch (whichItem) {
  351.                         case fileImport:
  352.                                     importMovie();
  353.                                     break;
  354.                         case fileExport:
  355.                                     exportMovie();
  356.                                     break;
  357.                         case fileQuit:
  358.                                     done = true;
  359.                                     break;
  360.                     }
  361.                     break;
  362.     }
  363.  
  364.     HiliteMenu(0);
  365.  
  366.     return done;
  367. }
  368.  
  369.  
  370. void main(void)
  371. {
  372.     OSErr err;
  373.     Boolean done = false;
  374.     long response;
  375.  
  376.     // initialize the world
  377.     InitGraf(&qd.thePort);
  378.     InitFonts();
  379.     InitWindows();
  380.     InitMenus();
  381.     TEInit();
  382.     InitDialogs(0L);
  383.     InitCursor();
  384.     MaxApplZone();
  385.  
  386.     // need system 7. slimey check
  387.     //     we use pop-up cdef and custom putfile
  388.     if (*(short *)SysVersion < 0x0700) return;
  389.  
  390.     // must have QuickTime around
  391.     if (Gestalt(gestaltQuickTime, &response)) return;
  392.  
  393.     err = EnterMovies();
  394.     if (err) return;
  395.  
  396.     SetMenuBar(GetNewMBar(kMyMBar));
  397.     DrawMenuBar();
  398.  
  399.     AddResMenu(GetMHandle(menuApple), 'DRVR');
  400.  
  401.     while (!done) {
  402.         EventRecord theEvent;
  403.  
  404.         SystemTask();
  405.         GetNextEvent(everyEvent, &theEvent);
  406.         switch (theEvent.what) {
  407.             case mouseDown:    {
  408.                                 short part;
  409.                                 WindowPtr whichWindow;
  410.  
  411.                                 part = FindWindow(theEvent.where, &whichWindow);
  412.                                 switch (part) {
  413.                                     case inMenuBar:
  414.                                                 done = doMenuItem(MenuSelect(theEvent.where));
  415.                                                 break;
  416.                                     case inSysWindow:
  417.                                                 SystemClick(&theEvent, whichWindow);
  418.                                                 break;
  419.                                 }
  420.                             }
  421.                             break;
  422.  
  423.             case keyDown:    {
  424.                             char c;
  425.  
  426.                             c = theEvent.message & charCodeMask;
  427.                             if (theEvent.modifiers & cmdKey)
  428.                                 done = doMenuItem(MenuKey(c));
  429.                             }
  430.                             break;
  431.         }
  432.  
  433.     }
  434. }
  435.